﻿using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;

namespace Historia.Controls
{
    /// <summary>
    /// Interaction logic for ctrChapitres.xaml
    /// </summary>
    public partial class ctrChapitres : UserControl
    {
        #region Membres
        protected DataManager _dm = null;
        #endregion

        #region Constructeurs

        public ctrChapitres()
        {
            InitializeComponent();
        }

        #endregion

        #region Propriétés

        public TreeViewItem TreeViewItemChapitre {
            get
            {
                if (this.tvChapitres.SelectedItem != null)
                {
                    if (((TreeViewItem)this.tvChapitres.SelectedItem).Parent == this.tvChapitres)
                {
                    return (TreeViewItem)this.tvChapitres.SelectedItem;
                }
                else
                {
                    return (TreeViewItem)((TreeViewItem)this.tvChapitres.SelectedItem).Parent;
                }
                }
                else
                {
                    return null;
                }
                
            }
        }

        public TreeViewItem TreeViewItemScene
        {
            get
            {
                if (this.tvChapitres.SelectedItem != null)
                {
                    if (((TreeViewItem)this.tvChapitres.SelectedItem).HasItems)
                    {
                        return null;
                    }
                    else
                    {
                        return ((TreeViewItem)this.tvChapitres.SelectedItem);
                    }
                }
                else
                {
                    return null;
                }
            }
        }
        
        #endregion

        #region Méthodes

        public void Init(ref DataManager dm)
        {
            this._dm = dm;
            this.tvChapitres.Items.Clear();
            this.DisplayData();
        }

        protected void DisplayData() {
            
 
            foreach (DataRow chap in this._dm.DB.Tables[DataManager.CHAPITES].Select(null,"ordre ASC"))
            {
                TreeViewItem tviChap = this.CreerTreeviewItemChapitre(chap);
                this.UpdateTreeviewItemFont(tviChap);

                foreach (DataRow s in this._dm.DB.Tables[DataManager.SCENES].Select("id_chapitre=" + chap.Field<Int32>("id_chapitre").ToString(), "ordre ASC"))
                {
                    this.CreerTreeviewItemScene(s, ref tviChap);
                }

                this.UpdateChapterStatus(tviChap);
            }
        }

        protected TreeViewItem CreerTreeviewItemChapitre(DataRow chapitre) {
            TreeViewItem tviChap = new TreeViewItem();


            tviChap.Tag = chapitre;

            StackPanel sp = new StackPanel();
            sp.Orientation = Orientation.Horizontal;
            CheckBox chk = new CheckBox();
            TextBlock txt = new TextBlock();
            chk.Padding = new Thickness(2);
            chk.VerticalAlignment = System.Windows.VerticalAlignment.Center;
            
            chk.IsChecked = chapitre.Field<bool>("visible");
            chk.Checked += new RoutedEventHandler(chkVisible_Checked);
            chk.Unchecked += new RoutedEventHandler(chkVisible_Unchecked);

            Rectangle rect = new Rectangle() { Width = 15, Height = 15 };
            rect.Fill = new SolidColorBrush(Colors.Red);
                        
            txt.Text = chapitre.Field<string>("nom");
            txt.Padding = new Thickness(2);
            txt.FontWeight = FontWeights.Bold;

            sp.Children.Add(chk);
            sp.Children.Add(rect);
            sp.Children.Add(txt);

            tviChap.Header = sp;

            this.tvChapitres.Items.Add(tviChap);

            return tviChap;
        }

  
        protected void CreerTreeviewItemScene(DataRow scene, ref TreeViewItem tviChapitre) {
            TreeViewItem tviScene = new TreeViewItem();
            tviScene.Tag = scene;
            StackPanel sp = new StackPanel();
            sp.Orientation = Orientation.Horizontal;
            CheckBox chk = new CheckBox();
                
            chk.IsChecked = scene.Field<bool>("visible");
            chk.Padding = new Thickness(2);
            chk.VerticalAlignment = System.Windows.VerticalAlignment.Center;
            chk.Checked += new RoutedEventHandler(chkVisible_Checked);
            chk.Unchecked += new RoutedEventHandler(chkVisible_Unchecked);

            ComboBox cbo = new ComboBox();
            cbo.Background = null;
            cbo.BorderBrush = null;
            cbo.Padding = new Thickness(2);
                
            ComboBoxItem cbiRouge = new ComboBoxItem();
            Rectangle rect = new Rectangle() {Width=15,Height=15};
            rect.Fill = new SolidColorBrush(Colors.Red);
            cbiRouge.Content = rect;
            cbo.Items.Add(cbiRouge);

            ComboBoxItem cbiOrange = new ComboBoxItem();
            rect = new Rectangle() { Width = 15, Height = 15 };
            rect.Fill = new SolidColorBrush(Colors.Orange);
            cbiOrange.Content = rect;
            cbo.Items.Add(cbiOrange);

            ComboBoxItem cbiJaune = new ComboBoxItem();
            rect = new Rectangle() { Width = 15, Height = 15 };
            rect.Fill = new SolidColorBrush(Colors.Yellow);
            cbiJaune.Content = rect;
            cbo.Items.Add(cbiJaune);

            ComboBoxItem cbiBleu = new ComboBoxItem();
            rect = new Rectangle() { Width = 15, Height = 15 };
            rect.Fill = new SolidColorBrush(Colors.Blue);
            cbiBleu.Content = rect;
            cbo.Items.Add(cbiBleu);

            ComboBoxItem cbiVert = new ComboBoxItem();
            rect = new Rectangle() { Width = 15, Height = 15 };
            rect.Fill = new SolidColorBrush(Colors.Green);
            cbiVert.Content = rect;
            cbo.Items.Add(cbiVert);

            cbo.SelectedIndex = scene.Field<Int16>("statut");
            cbo.SelectionChanged += new SelectionChangedEventHandler(cbo_SelectionChanged);

            TextBlock txt = new TextBlock();
            txt.Text = scene.Field<string>("nom");
            txt.Padding = new Thickness(2);
                
            sp.Children.Add(chk);
            sp.Children.Add(cbo);
            sp.Children.Add(txt);
            tviScene.Header = sp;
            tviChapitre.Items.Add(tviScene);

            this.UpdateTreeviewItemFont(tviScene);
        }

        protected void NouveauChapitre() {
            DataRow chap = this._dm.DB.Tables[DataManager.CHAPITES].NewRow();
            Int32 chapCount = this._dm.DB.Tables[DataManager.CHAPITES].Select(null, null, DataViewRowState.CurrentRows).Length;
            chap.SetField<string>("nom", "Chapitre " + (chapCount+1).ToString());
            chap.SetField<Int16>("ordre",(Int16)chapCount);
            this._dm.DB.Tables[DataManager.CHAPITES].Rows.Add(chap);
            
            TreeViewItem tviChap =  this.CreerTreeviewItemChapitre(chap);
            this.NouvelleScene(ref chap, ref tviChap);
        }

        protected DataRow NouvelleScene(ref DataRow chapitre, ref TreeViewItem tviChapitre, bool createTreeViewItem = true) {
            DataRow s = this._dm.DB.Tables[DataManager.SCENES].NewRow();
            s.SetField<Int32>("id_chapitre", chapitre.Field<Int32>("id_chapitre"));
            s.SetField<Int16>("statut", 0);

            DataRow[] drs = this._dm.DB.Tables[DataManager.SCENES].Select("id_chapitre = " + chapitre.Field<Int32>("id_chapitre").ToString(),null,DataViewRowState.CurrentRows);
           
            if (drs != null){
                s.SetField<string>("nom", "Scène " + Convert.ToInt16(drs.Length+1).ToString());
                s.SetField<Int16>("ordre",Convert.ToInt16(drs.Length));
            }else
            {
                s.SetField<string>("nom", "Scène 1");
                s.SetField<Int16>("ordre",0);
            }

            this._dm.DB.Tables[DataManager.SCENES].Rows.Add(s);

            if ((tviChapitre != null) && (createTreeViewItem))
            {
                this.CreerTreeviewItemScene(s, ref tviChapitre);
            }
            return s;
        }

        protected void CopyScene() {
            if ((this.TreeViewItemChapitre != null) && (this.TreeViewItemScene != null))
            {
                DataRow drChap = (DataRow)this.TreeViewItemChapitre.Tag;
                TreeViewItem tviChap = this.TreeViewItemChapitre;
                DataRow oldScene = (DataRow)this.TreeViewItemScene.Tag;
                DataRow newScene = this.NouvelleScene(ref drChap, ref tviChap,false);
                newScene.SetField<string>("nom", "Copie de " + oldScene.Field<string>("nom"));
                newScene.SetField<string>("resume", oldScene.Field<string>("resume"));
                newScene.SetField<string>("texte", oldScene.Field<string>("texte"));
                newScene.SetField<bool>("visible", oldScene.Field<bool>("visible"));
                newScene.SetField<Int16>("statut", oldScene.Field<Int16>("statut"));
                newScene.SetField<Int16?>("annee", oldScene.Field<Int16?>("annee"));
                newScene.SetField<Int16?>("mois", oldScene.Field<Int16?>("mois"));
                newScene.SetField<Int16?>("jour", oldScene.Field<Int16?>("jour"));

                //Personnages
                foreach (DataRow p in oldScene.GetChildRows("FK_Scenes_Personnages_Scenes"))
                {
                    DataRow sp = this._dm.DB.Tables[DataManager.PERSONNAGES_SCENES].NewRow();
                    sp.SetField<Int32>("id_personnage", p.Field<Int32>("id_personnage"));
                    sp.SetField<Int32>("id_scene", newScene.Field<Int32>("id_scene"));
                    this._dm.DB.Tables[DataManager.PERSONNAGES_SCENES].Rows.Add(sp);
                }

                //Lieux
                foreach (DataRow l in oldScene.GetChildRows("FK_Scenes_Lieux_Scenes"))
                {
                    DataRow ls = this._dm.DB.Tables[DataManager.LIEUX_SCENES].NewRow();
                    ls.SetField<Int32>("id_lieu", l.Field<Int32>("id_lieu"));
                    ls.SetField<Int32>("id_scene", newScene.Field<Int32>("id_scene"));
                    this._dm.DB.Tables[DataManager.LIEUX_SCENES].Rows.Add(ls);
                }

                //Items
                foreach (DataRow i in oldScene.GetChildRows("FK_Scenes_Items_Scenes"))
                {
                    DataRow its = this._dm.DB.Tables[DataManager.ITEMS_SCENES].NewRow();
                    its.SetField<Int32>("id_item", i.Field<Int32>("id_item"));
                    its.SetField<Int32>("id_scene", newScene.Field<Int32>("id_scene"));
                    this._dm.DB.Tables[DataManager.ITEMS_SCENES].Rows.Add(its);
                }

                //Fils
                foreach (DataRow f in oldScene.GetChildRows("FK_Scenes_Fils_Scenes"))
                {
                    DataRow fs = this._dm.DB.Tables[DataManager.FILS_SCENES].NewRow();
                    fs.SetField<Int32>("id_fil", f.Field<Int32>("id_fil"));
                    fs.SetField<Int32>("id_scene", newScene.Field<Int32>("id_scene"));
                    this._dm.DB.Tables[DataManager.FILS_SCENES].Rows.Add(fs);
                }

                if (tviChap != null)
                {
                    this.CreerTreeviewItemScene(newScene, ref tviChap);

                }
            }
            else
            {
                MessageBox.Show("Vous devez sélectionner une scène au préalable.", "Nouvelle Scène", MessageBoxButton.OK, MessageBoxImage.Warning);
            }
        }

        protected void UpdateChapterStatus(TreeViewItem tviChapiter) {
            Int32 index = 4;
            foreach (TreeViewItem item in tviChapiter.Items)
            {
                if (((CheckBox)((StackPanel)item.Header).Children[0]).IsChecked == true)
                {
                    if (((ComboBox)((StackPanel)item.Header).Children[1]).SelectedIndex < index)
                    {
                        index = ((ComboBox)((StackPanel)item.Header).Children[1]).SelectedIndex;
                    }
                }
                
            }
            switch (index)
            {
               case 0:
                    ((Rectangle)((StackPanel)tviChapiter.Header).Children[1]).Fill = new SolidColorBrush(Colors.Red);
            break;
               case 1:
            ((Rectangle)((StackPanel)tviChapiter.Header).Children[1]).Fill = new SolidColorBrush(Colors.Orange);
            break;
               case 2:
            ((Rectangle)((StackPanel)tviChapiter.Header).Children[1]).Fill = new SolidColorBrush(Colors.Yellow);
            break;
               case 3:
            ((Rectangle)((StackPanel)tviChapiter.Header).Children[1]).Fill = new SolidColorBrush(Colors.Blue);
            break;
               case 4:
            ((Rectangle)((StackPanel)tviChapiter.Header).Children[1]).Fill = new SolidColorBrush(Colors.Green);
            break;
                default:
                    break;
            }

        }

        protected void UpdateTreeviewItemFont(TreeViewItem tvi) {
            CheckBox chk = ((CheckBox)((StackPanel)tvi.Header).Children[0]);
            if (chk.IsChecked == true)
            {
                ((TextBlock)((StackPanel)tvi.Header).Children[2]).FontStyle = FontStyles.Normal;
                ((TextBlock)((StackPanel)tvi.Header).Children[2]).TextDecorations = null;
                
            }
            else
            {
                ((TextBlock)((StackPanel)tvi.Header).Children[2]).FontStyle = FontStyles.Italic;
                ((TextBlock)((StackPanel)tvi.Header).Children[2]).TextDecorations = TextDecorations.Strikethrough;
            }
            
        }
        #endregion

        #region Events

        public static readonly RoutedEvent SelectionChangedEvent = EventManager.RegisterRoutedEvent(
    "SelectionChanged", RoutingStrategy.Bubble, typeof(RoutedEventHandler), typeof(ctrChapitres));

        // Provide CLR accessors for the event
        public event RoutedEventHandler SelectionChanged
        {
            add { AddHandler(SelectionChangedEvent, value); }
            remove { RemoveHandler(SelectionChangedEvent, value); }
        }

        #endregion

        private void btnNouveauChapitre_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                this.NouveauChapitre();
            }
            catch (Exception)
            {
                
                throw;
            }
        }

        private void chkVisible_Checked(object sender, RoutedEventArgs e)
        {
            TreeViewItem tvi = (TreeViewItem)((StackPanel)((CheckBox)sender).Parent).Parent;
            DataRow dr = (DataRow)tvi.Tag;
            dr.SetField<bool>("visible", true);
            
            this.UpdateTreeviewItemFont(tvi);

            if (tvi.HasItems)
            {
                this.UpdateChapterStatus(tvi);
            }
            else
            {
                this.UpdateChapterStatus((TreeViewItem)tvi.Parent);
            }
        }
        
        private void chkVisible_Unchecked(object sender, RoutedEventArgs e)
        {
           TreeViewItem tvi = (TreeViewItem)((StackPanel)((CheckBox)sender).Parent).Parent;
           DataRow dr = (DataRow)tvi.Tag;
           dr.SetField<bool>("visible", false);

           this.UpdateTreeviewItemFont(tvi);
           
            if (tvi.HasItems)
	        {
                this.UpdateChapterStatus(tvi);
            }
            else
            {
                this.UpdateChapterStatus((TreeViewItem)tvi.Parent);
            }
           
        }


        private void btnNouvelleScene_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                if (this.TreeViewItemChapitre != null)
                {
                    DataRow drChap = (DataRow)this.TreeViewItemChapitre.Tag;
                    TreeViewItem tviChap = this.TreeViewItemChapitre;
                    this.NouvelleScene(ref drChap, ref tviChap);
                }
                else
                {
                    MessageBox.Show("Vous devez sélectionner un chapitre au préalable.", "Nouvelle Scène", MessageBoxButton.OK,MessageBoxImage.Warning);
                }
            }
            catch (Exception)
            {

                throw;
            }
        }

        private void btnSupprimer_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                if (this.tvChapitres.SelectedItem != null)
                {
                    // Est-ce une scène que l'utilisateur veut supprimer?
                    if (this.TreeViewItemScene != null)
                    {
                        // Est-ce que l'on supprime la scène?
                        if (MessageBox.Show("Êtes-vous certain de vouloir supprimer cette scène?","Supprimer",MessageBoxButton.YesNo,MessageBoxImage.Question) == MessageBoxResult.Yes)
                        {
                            // Oui on suppime la scène de la bd
                            DataRow drScene = (DataRow)this.TreeViewItemScene.Tag;
                            drScene.Delete();

                            // On enlève le treeviewitem
                            this.TreeViewItemChapitre.Items.Remove(this.TreeViewItemScene);
                        }
                    }
                        // Est-ce un chapitre que l'utilisateur veut supprimer?
                    else if(this.TreeViewItemChapitre != null)
                    {
                        // Est-ce que l'on supprime le chapitre et ses scènes?
                        if (MessageBox.Show("Êtes-vous certain de vouloir supprimer ce chapitre et ses scènes?", "Supprimer", MessageBoxButton.YesNo, MessageBoxImage.Question) == MessageBoxResult.Yes)
                        {
                            // Oui on suppime le chapitre de la bd et ses scènes
                            DataRow drChap = (DataRow)this.TreeViewItemChapitre.Tag;
                            drChap.Delete();
                            //DataRow drScene = (DataRow)this.TreeViewItemScene.Tag;
                            //drScene.Delete();

                            // On enlève le treeviewitem
                            this.tvChapitres.Items.Remove(this.TreeViewItemChapitre);
                        }
                    }
                }
                else
                {
                    MessageBox.Show("Aucun item n'est sélectionné pour être supprimé.", "Supprimer", MessageBoxButton.OK,MessageBoxImage.Warning);
                }
            }
            catch (Exception)
            {
                
                throw;
            }
        }

        private void btnAgrandirTout_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                foreach (TreeViewItem tvi in this.tvChapitres.Items)
                {
                    tvi.IsExpanded = true;
                }
            }
            catch (Exception)
            {
                
                throw;
            }
        }

        private void btnRefermerTout_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                foreach (TreeViewItem tvi in this.tvChapitres.Items)
                {
                    tvi.IsExpanded = false;
                }
            }
            catch (Exception)
            {
                
                throw;
            }
        }

        private void btnDeplacerBas_Click(object sender, RoutedEventArgs e)
        {
            this.tvChapitres.SelectedItemChanged -= new RoutedPropertyChangedEventHandler<object>(tvChapitres_SelectedItemChanged);

            try
            {
                // Est-ce que c'est une scène que l'on déplace?
                if (this.TreeViewItemScene != null)
                {
                    TreeViewItem tviScene = this.TreeViewItemScene;
                    Int32 index = this.TreeViewItemChapitre.Items.IndexOf(tviScene);
                    if (index < this.TreeViewItemChapitre.Items.Count-1)
                    {
                        // On insert la scène sous la scène suivante
                        this.TreeViewItemChapitre.Items.Remove(tviScene);
                        this.TreeViewItemChapitre.Items.Insert(index + 1, tviScene);
                        tviScene.IsSelected = true;

                        // On update le champ ordre
                        DataRow drSceneCourrante = (DataRow)tviScene.Tag;
                        drSceneCourrante.SetField<Int16>("ordre", (Int16)(drSceneCourrante.Field<Int16>("ordre") + 1));

                        DataRow drScenePrecedante = (DataRow)((TreeViewItem)this.TreeViewItemChapitre.Items[index]).Tag;
                        drScenePrecedante.SetField<Int16>("ordre", (Int16)(drScenePrecedante.Field<Int16>("ordre") - 1));
                    }
                    else if (this.tvChapitres.Items.IndexOf(this.TreeViewItemChapitre) + 1 <= this.tvChapitres.Items.Count -1)
                    {
                        // La scène est déplacé vers le chapitre suivant
                        this.TreeViewItemChapitre.Items.Remove(tviScene);
                        TreeViewItem tviChap = (TreeViewItem)this.tvChapitres.Items[this.tvChapitres.Items.IndexOf(this.TreeViewItemChapitre) + 1];
                        tviChap.Items.Insert(0,tviScene);
                        tviScene.IsSelected = true;

                        // On incémente de 1 le champ ordre de tous les enregistrements du chapitre suivant
                        DataRow drChapSuivant = (DataRow)tviChap.Tag;
                        foreach (DataRow dr in this._dm.DB.Tables[DataManager.SCENES].Select("id_chapitre=" + drChapSuivant.Field<Int32>("id_chapitre").ToString()))
                        {
                            dr.SetField<Int16>("ordre", (Int16)(dr.Field<Int16>("ordre") + 1));
                        }

                        // On update le champ ordre à 0
                        DataRow drSceneCourrante = (DataRow)tviScene.Tag;
                        drSceneCourrante.SetField<Int32>("id_chapitre", drChapSuivant.Field<Int32>("id_chapitre"));
                        drSceneCourrante.SetField<Int16>("ordre",0);
           
                    }

                }
                else if (this.TreeViewItemChapitre != null)
                {
                    // On déplace un chapitre
                    TreeViewItem tviChap = this.TreeViewItemChapitre;
                    Int32 index = this.tvChapitres.Items.IndexOf(tviChap);
                    if (index < this.tvChapitres.Items.Count-1)
                    {
                        this.tvChapitres.Items.Remove(tviChap);
                        this.tvChapitres.Items.Insert(index + 1, tviChap);
                        tviChap.IsSelected = true;

                        // On update le champ ordre
                        DataRow drChapCourrante = (DataRow)tviChap.Tag;
                        drChapCourrante.SetField<Int16>("ordre", (Int16)(drChapCourrante.Field<Int16>("ordre") + 1));

                        DataRow drChapPrecedante = (DataRow)((TreeViewItem)this.tvChapitres.Items[index]).Tag;
                        drChapPrecedante.SetField<Int16>("ordre", (Int16)(drChapPrecedante.Field<Int16>("ordre") - 1));
                    }
                }
                // On lance l'événement SelectedItemChanged
                this.RaiseEvent(new RoutedEventArgs(SelectionChangedEvent));
            }
            catch (Exception)
            {
                
                throw;
            }
            finally
            {
                this.tvChapitres.SelectedItemChanged += new RoutedPropertyChangedEventHandler<object>(tvChapitres_SelectedItemChanged);
            }
        }

        private void btnDeplacerHaut_Click(object sender, RoutedEventArgs e)
        {
            this.tvChapitres.SelectedItemChanged -= new RoutedPropertyChangedEventHandler<object>(tvChapitres_SelectedItemChanged);

            try
            {
                // Est-ce que c'est une scène que l'on déplace?
                if (this.TreeViewItemScene != null)
                {
                    // On déplace une scène
                    TreeViewItem tviScene = this.TreeViewItemScene;
                    Int32 index = this.TreeViewItemChapitre.Items.IndexOf(tviScene);
                    if (index > 0)
                    {
                        this.TreeViewItemChapitre.Items.Remove(tviScene);
                        this.TreeViewItemChapitre.Items.Insert(index - 1, tviScene);
                        tviScene.IsSelected = true;

                        // On update le champ ordre
                        DataRow drSceneCourrante = (DataRow)tviScene.Tag;
                        drSceneCourrante.SetField<Int16>("ordre", (Int16)(drSceneCourrante.Field<Int16>("ordre") - 1));

                        DataRow drSceneSuivant = (DataRow)((TreeViewItem)this.TreeViewItemChapitre.Items[index]).Tag;
                        drSceneSuivant.SetField<Int16>("ordre", (Int16)(drSceneSuivant.Field<Int16>("ordre") + 1));
                    }
                    else if (this.tvChapitres.Items.IndexOf(this.TreeViewItemChapitre) - 1 >= 0)
                    {
                        // La scène est déplacé vers le chapitre précédant
                        this.TreeViewItemChapitre.Items.Remove(tviScene);
                        TreeViewItem tviChap = (TreeViewItem)this.tvChapitres.Items[this.tvChapitres.Items.IndexOf(this.TreeViewItemChapitre) - 1];
                        tviChap.Items.Add(tviScene);
                        tviScene.IsSelected = true;

                        // On update le champ ordre à 0
                        DataRow drChapPrecedant = (DataRow)tviChap.Tag;
                        DataRow drSceneCourrante = (DataRow)tviScene.Tag;
                        drSceneCourrante.SetField<Int32>("id_chapitre", drChapPrecedant.Field<Int32>("id_chapitre"));
                        drSceneCourrante.SetField<Int16>("ordre", (Int16)(tviChap.Items.Count - 1));
                    }

                }
                else if (this.TreeViewItemChapitre != null)
                {
                    // On déplace un chapitre
                    TreeViewItem tviChap = this.TreeViewItemChapitre;
                    Int32 index = this.tvChapitres.Items.IndexOf(tviChap);
                    if (index > 0)
                    {
                        this.tvChapitres.Items.Remove(tviChap);
                        this.tvChapitres.Items.Insert(index - 1, tviChap);
                        tviChap.IsSelected = true;

                        // On update le champ ordre
                        DataRow drChapCourrante = (DataRow)tviChap.Tag;
                        drChapCourrante.SetField<Int16>("ordre", (Int16)(drChapCourrante.Field<Int16>("ordre") - 1));

                        DataRow drChapPrecedante = (DataRow)((TreeViewItem)this.tvChapitres.Items[index]).Tag;
                        drChapPrecedante.SetField<Int16>("ordre", (Int16)(drChapPrecedante.Field<Int16>("ordre") + 1));
                    }
                }
                // On lance l'événement SelectedItemChanged
                this.RaiseEvent(new RoutedEventArgs(SelectionChangedEvent));
            }
            catch (Exception ex)
            {

                throw;
            }
            finally
            {
                this.tvChapitres.SelectedItemChanged +=new RoutedPropertyChangedEventHandler<object>(tvChapitres_SelectedItemChanged);
            }
        }

        private void cbo_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {

            ((TreeViewItem)((StackPanel)((ComboBox)sender).Parent).Parent).IsSelected = true;
            DataRow dr = (DataRow)this.TreeViewItemScene.Tag;
            dr.SetField<Int16>("statut", (Int16)((ComboBox)sender).SelectedIndex);
            this.UpdateChapterStatus(this.TreeViewItemChapitre);
        }

        private void tvChapitres_SelectedItemChanged(object sender, RoutedPropertyChangedEventArgs<object> e)
        {
            this.RaiseEvent(new RoutedEventArgs(SelectionChangedEvent));
        }

        private void btnCopierScene_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                this.CopyScene();
            }
            catch (Exception ex)
            {
                
                throw;
            }
        }
    }
}
